1   /*
2    * Copyright (c) 2003, 2005, Oracle and/or its affiliates. All rights reserved.
3    * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4    *
5    * This code is free software; you can redistribute it and/or modify it
6    * under the terms of the GNU General Public License version 2 only, as
7    * published by the Free Software Foundation.
8    *
9    * This code is distributed in the hope that it will be useful, but WITHOUT
10   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11   * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12   * version 2 for more details (a copy is included in the LICENSE file that
13   * accompanied this code).
14   *
15   * You should have received a copy of the GNU General Public License version
16   * 2 along with this work; if not, write to the Free Software Foundation,
17   * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18   *
19   * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20   * or visit www.oracle.com if you need additional information or have any
21   * questions.
22   */
23  
24  /*
25   * @test
26   * @bug 4851776 4907265 6177836 6876282
27   * @summary Some tests for the divide methods.
28   * @author Joseph D. Darcy
29   */
30  
31  import java.math.*;
32  import static java.math.BigDecimal.*;
33  
34  public class DivideTests {
35  
36      // Preliminary exact divide method; could be used for comparison
37      // purposes.
38      BigDecimal anotherDivide(BigDecimal dividend, BigDecimal divisor) {
39          /*
40           * Handle zero cases first.
41           */
42          if (divisor.signum() == 0) {   // x/0
43              if (dividend.signum() == 0)    // 0/0
44                  throw new ArithmeticException("Division undefined");  // NaN
45              throw new ArithmeticException("Division by zero");
46          }
47          if (dividend.signum() == 0)        // 0/y
48              return BigDecimal.ZERO;
49          else {
50              /*
51               * Determine if there is a result with a terminating
52               * decimal expansion.  Putting aside overflow and
53               * underflow considerations, the existance of an exact
54               * result only depends on the ratio of the intVal's of the
55               * dividend (i.e. this) and and divisor since the scales
56               * of the argument just affect where the decimal point
57               * lies.
58               *
59               * For the ratio of (a = this.intVal) and (b =
60               * divisor.intVal) to have a finite decimal expansion,
61               * once a/b is put in lowest terms, b must be equal to
62               * (2^i)*(5^j) for some integer i,j >= 0.  Therefore, we
63               * first compute to see if b_prime =(b/gcd(a,b)) is equal
64               * to (2^i)*(5^j).
65               */
66              BigInteger TWO  = BigInteger.valueOf(2);
67              BigInteger FIVE = BigInteger.valueOf(5);
68              BigInteger TEN  = BigInteger.valueOf(10);
69  
70              BigInteger divisorIntvalue  = divisor.scaleByPowerOfTen(divisor.scale()).toBigInteger().abs();
71              BigInteger dividendIntvalue = dividend.scaleByPowerOfTen(dividend.scale()).toBigInteger().abs();
72  
73              BigInteger b_prime = divisorIntvalue.divide(dividendIntvalue.gcd(divisorIntvalue));
74  
75              boolean goodDivisor = false;
76              int i=0, j=0;
77  
78              badDivisor: {
79                  while(! b_prime.equals(BigInteger.ONE) ) {
80                      int b_primeModTen = b_prime.mod(TEN).intValue() ;
81  
82                      switch(b_primeModTen) {
83                      case 0:
84                          // b_prime divisible by 10=2*5, increment i and j
85                          i++;
86                          j++;
87                          b_prime = b_prime.divide(TEN);
88                          break;
89  
90                      case 5:
91                          // b_prime divisible by 5, increment j
92                          j++;
93                          b_prime = b_prime.divide(FIVE);
94                          break;
95  
96                      case 2:
97                      case 4:
98                      case 6:
99                      case 8:
100                         // b_prime divisible by 2, increment i
101                         i++;
102                         b_prime = b_prime.divide(TWO);
103                         break;
104 
105                     default: // hit something we shouldn't have
106                         b_prime = BigInteger.ONE; // terminate loop
107                         break badDivisor;
108                     }
109                 }
110 
111                 goodDivisor = true;
112             }
113 
114             if( ! goodDivisor ) {
115                 throw new ArithmeticException("Non terminating decimal expansion");
116             }
117             else {
118                 // What is a rule for determining how many digits are
119                 // needed?  Once that is determined, cons up a new
120                 // MathContext object and pass it on to the divide(bd,
121                 // mc) method; precision == ?, roundingMode is unnecessary.
122 
123                 // Are we sure this is the right scale to use?  Should
124                 // also determine a precision-based method.
125                 MathContext mc = new MathContext(dividend.precision() +
126                                                  (int)Math.ceil(
127                                                       10.0*divisor.precision()/3.0),
128                                                  RoundingMode.UNNECESSARY);
129                 // Should do some more work here to rescale, etc.
130                 return dividend.divide(divisor, mc);
131             }
132         }
133     }
134 
135     public static int powersOf2and5() {
136         int failures = 0;
137 
138         for(int i = 0; i < 6; i++) {
139             int powerOf2 = (int)StrictMath.pow(2.0, i);
140 
141             for(int j = 0; j < 6; j++) {
142                 int powerOf5 = (int)StrictMath.pow(5.0, j);
143                 int product;
144 
145                 BigDecimal bd;
146 
147                 try {
148                     bd = BigDecimal.ONE.divide(new BigDecimal(product=powerOf2*powerOf5));
149                 } catch (ArithmeticException e) {
150                     failures++;
151                     System.err.println((new BigDecimal(powerOf2)).toString() + " / " +
152                                        (new BigDecimal(powerOf5)).toString() + " threw an exception.");
153                     e.printStackTrace();
154                 }
155 
156                 try {
157                     bd = new BigDecimal(powerOf2).divide(new BigDecimal(powerOf5));
158                 } catch (ArithmeticException e) {
159                     failures++;
160                     System.err.println((new BigDecimal(powerOf2)).toString() + " / " +
161                                        (new BigDecimal(powerOf5)).toString() + " threw an exception.");
162                     e.printStackTrace();
163                 }
164 
165                 try {
166                     bd = new BigDecimal(powerOf5).divide(new BigDecimal(powerOf2));
167                 } catch (ArithmeticException e) {
168                     failures++;
169                     System.err.println((new BigDecimal(powerOf5)).toString() + " / " +
170                                        (new BigDecimal(powerOf2)).toString() + " threw an exception.");
171 
172                     e.printStackTrace();
173                 }
174 
175             }
176         }
177         return failures;
178     }
179 
180     public static int nonTerminating() {
181         int failures = 0;
182         int[] primes = {1, 3, 7, 13, 17};
183 
184         // For each pair of prime products, verify the ratio of
185         // non-equal products has a non-terminating expansion.
186 
187         for(int i = 0; i < primes.length; i++) {
188             for(int j = i+1; j < primes.length; j++) {
189 
190                 for(int m = 0; m < primes.length; m++) {
191                     for(int n = m+1; n < primes.length; n++) {
192                         int dividend = primes[i] * primes[j];
193                         int divisor  = primes[m] * primes[n];
194 
195                         if ( ((dividend/divisor) * divisor) != dividend ) {
196                             try {
197                                 BigDecimal quotient = (new BigDecimal(dividend).
198                                                        divide(new BigDecimal(divisor)));
199                                 failures++;
200                                 System.err.println("Exact quotient " + quotient.toString() +
201                                                    " returned for non-terminating fraction " +
202                                                    dividend + " / " + divisor + ".");
203                             }
204                             catch (ArithmeticException e) {
205                                 ; // Correct result
206                             }
207                         }
208 
209                     }
210                 }
211             }
212         }
213 
214         return failures;
215     }
216 
217     public static int properScaleTests(){
218         int failures = 0;
219 
220         BigDecimal[][] testCases = {
221             {new BigDecimal("1"),       new BigDecimal("5"),            new BigDecimal("2e-1")},
222             {new BigDecimal("1"),       new BigDecimal("50e-1"),        new BigDecimal("2e-1")},
223             {new BigDecimal("10e-1"),   new BigDecimal("5"),            new BigDecimal("2e-1")},
224             {new BigDecimal("1"),       new BigDecimal("500e-2"),       new BigDecimal("2e-1")},
225             {new BigDecimal("100e-2"),  new BigDecimal("5"),            new BigDecimal("20e-2")},
226             {new BigDecimal("1"),       new BigDecimal("32"),           new BigDecimal("3125e-5")},
227             {new BigDecimal("1"),       new BigDecimal("64"),           new BigDecimal("15625e-6")},
228             {new BigDecimal("1.0000000"),       new BigDecimal("64"),   new BigDecimal("156250e-7")},
229         };
230 
231 
232         for(BigDecimal[] tc : testCases) {
233             BigDecimal quotient;
234             if (! (quotient = tc[0].divide(tc[1])).equals(tc[2]) ) {
235                 failures++;
236                 System.err.println("Unexpected quotient from " + tc[0] + " / " + tc[1] +
237                                    "; expected " + tc[2] + " got " + quotient);
238             }
239         }
240 
241         return failures;
242     }
243 
244     public static int trailingZeroTests() {
245         int failures = 0;
246 
247         MathContext mc = new MathContext(3, RoundingMode.FLOOR);
248         BigDecimal[][] testCases = {
249             {new BigDecimal("19"),      new BigDecimal("100"),          new BigDecimal("0.19")},
250             {new BigDecimal("21"),      new BigDecimal("110"),          new BigDecimal("0.190")},
251         };
252 
253         for(BigDecimal[] tc : testCases) {
254             BigDecimal quotient;
255             if (! (quotient = tc[0].divide(tc[1], mc)).equals(tc[2]) ) {
256                 failures++;
257                 System.err.println("Unexpected quotient from " + tc[0] + " / " + tc[1] +
258                                    "; expected " + tc[2] + " got " + quotient);
259             }
260         }
261 
262         return failures;
263     }
264 
265     public static int scaledRoundedDivideTests() {
266         int failures = 0;
267         // Tests of the traditional scaled divide under different
268         // rounding modes.
269 
270         // Encode rounding mode and scale for the divide in a
271         // BigDecimal with the significand equal to the rounding mode
272         // and the scale equal to the number's scale.
273 
274         // {dividend, dividisor, rounding, quotient}
275         BigDecimal a = new BigDecimal("31415");
276         BigDecimal a_minus = a.negate();
277         BigDecimal b = new BigDecimal("10000");
278 
279         BigDecimal c = new BigDecimal("31425");
280         BigDecimal c_minus = c.negate();
281 
282          // Ad hoc tests
283         BigDecimal d = new BigDecimal(new BigInteger("-37361671119238118911893939591735"), 10);
284         BigDecimal e = new BigDecimal(new BigInteger("74723342238476237823787879183470"), 15);
285 
286         BigDecimal[][] testCases = {
287             {a,         b,      BigDecimal.valueOf(ROUND_UP, 3),        new BigDecimal("3.142")},
288             {a_minus,   b,      BigDecimal.valueOf(ROUND_UP, 3),        new BigDecimal("-3.142")},
289 
290             {a,         b,      BigDecimal.valueOf(ROUND_DOWN, 3),      new BigDecimal("3.141")},
291             {a_minus,   b,      BigDecimal.valueOf(ROUND_DOWN, 3),      new BigDecimal("-3.141")},
292 
293             {a,         b,      BigDecimal.valueOf(ROUND_CEILING, 3),   new BigDecimal("3.142")},
294             {a_minus,   b,      BigDecimal.valueOf(ROUND_CEILING, 3),   new BigDecimal("-3.141")},
295 
296             {a,         b,      BigDecimal.valueOf(ROUND_FLOOR, 3),     new BigDecimal("3.141")},
297             {a_minus,   b,      BigDecimal.valueOf(ROUND_FLOOR, 3),     new BigDecimal("-3.142")},
298 
299             {a,         b,      BigDecimal.valueOf(ROUND_HALF_UP, 3),   new BigDecimal("3.142")},
300             {a_minus,   b,      BigDecimal.valueOf(ROUND_HALF_UP, 3),   new BigDecimal("-3.142")},
301 
302             {a,         b,      BigDecimal.valueOf(ROUND_DOWN, 3),      new BigDecimal("3.141")},
303             {a_minus,   b,      BigDecimal.valueOf(ROUND_DOWN, 3),      new BigDecimal("-3.141")},
304 
305             {a,         b,      BigDecimal.valueOf(ROUND_HALF_EVEN, 3), new BigDecimal("3.142")},
306             {a_minus,   b,      BigDecimal.valueOf(ROUND_HALF_EVEN, 3), new BigDecimal("-3.142")},
307 
308             {c,         b,      BigDecimal.valueOf(ROUND_HALF_EVEN, 3), new BigDecimal("3.142")},
309             {c_minus,   b,      BigDecimal.valueOf(ROUND_HALF_EVEN, 3), new BigDecimal("-3.142")},
310 
311             {d,         e,      BigDecimal.valueOf(ROUND_HALF_UP, -5),   BigDecimal.valueOf(-1, -5)},
312             {d,         e,      BigDecimal.valueOf(ROUND_HALF_DOWN, -5), BigDecimal.valueOf(0, -5)},
313             {d,         e,      BigDecimal.valueOf(ROUND_HALF_EVEN, -5), BigDecimal.valueOf(0, -5)},
314         };
315 
316         for(BigDecimal tc[] : testCases) {
317             int scale = tc[2].scale();
318             int rm = tc[2].unscaledValue().intValue();
319 
320             BigDecimal quotient = tc[0].divide(tc[1], scale, rm);
321             if (!quotient.equals(tc[3])) {
322                 failures++;
323                 System.err.println("Unexpected quotient from " + tc[0] + " / " + tc[1] +
324                                    " scale " + scale + " rounding mode " + RoundingMode.valueOf(rm) +
325                                    "; expected " + tc[3] + " got " + quotient);
326             }
327         }
328 
329         // 6876282
330         BigDecimal[][] testCases2 = {
331             // { dividend, divisor, expected quotient }
332             { new BigDecimal(3090), new BigDecimal(7), new BigDecimal(441) },
333             { new BigDecimal("309000000000000000000000"), new BigDecimal("700000000000000000000"),
334               new BigDecimal(441) },
335             { new BigDecimal("962.430000000000"), new BigDecimal("8346463.460000000000"),
336               new BigDecimal("0.000115309916") },
337             { new BigDecimal("18446744073709551631"), new BigDecimal("4611686018427387909"),
338               new BigDecimal(4) },
339             { new BigDecimal("18446744073709551630"), new BigDecimal("4611686018427387909"),
340               new BigDecimal(4) },
341             { new BigDecimal("23058430092136939523"), new BigDecimal("4611686018427387905"),
342               new BigDecimal(5) },
343             { new BigDecimal("-18446744073709551661"), new BigDecimal("-4611686018427387919"),
344               new BigDecimal(4) },
345             { new BigDecimal("-18446744073709551660"), new BigDecimal("-4611686018427387919"),
346               new BigDecimal(4) },
347         };
348 
349         for (BigDecimal test[] : testCases2) {
350             BigDecimal quo = test[0].divide(test[1], RoundingMode.HALF_UP);
351             if (!quo.equals(test[2])) {
352                 failures++;
353                 System.err.println("Unexpected quotient from " + test[0] + " / " + test[1] +
354                                    " rounding mode HALF_UP" +
355                                    "; expected " + test[2] + " got " + quo);
356             }
357         }
358         return failures;
359     }
360 
361     public static void main(String argv[]) {
362         int failures = 0;
363 
364         failures += powersOf2and5();
365         failures += nonTerminating();
366         failures += properScaleTests();
367         failures += trailingZeroTests();
368         failures += scaledRoundedDivideTests();
369 
370         if (failures > 0) {
371             throw new RuntimeException("Incurred " + failures +
372                                        " failures while testing exact divide.");
373         }
374     }
375 }